#include "infrared\infrared.h"

/* 五个位置检测的总数 */
uint32_t IRA_Count = 0;
uint32_t IRB_Count = 0;
uint32_t IRC_Count = 0;
uint32_t IRD_Count = 0;
uint32_t IRE_Count = 0;
// 定义互斥信号量句柄
SemaphoreHandle_t xMutexA;
// 定义互斥信号量句柄
SemaphoreHandle_t xMutexB;
// 定义互斥信号量句柄
SemaphoreHandle_t xMutexC;
// 定义互斥信号量句柄
SemaphoreHandle_t xMutexD;
// 定义互斥信号量句柄
SemaphoreHandle_t xMutexE;

/*
 * 红外A通道获取值
 * @说明：由于采集时是低电平有效，所以返回值为0时表示有信号，返回值为1时表示无信号
 */
uint8_t get_IRA_Value(void)
{
	return HAL_GPIO_ReadPin(HW1_GPIO_Port, HW1_Pin);
}

/*
 * 红外B通道获取值
 * @说明：由于采集时是低电平有效，所以返回值为0时表示有信号，返回值为1时表示无信号
 */
uint8_t get_IRB_Value(void)
{
	return HAL_GPIO_ReadPin(HW2_GPIO_Port, HW2_Pin);
}

/*
 * 红外C通道获取值
 * @说明：由于采集时是低电平有效，所以返回值为0时表示有信号，返回值为1时表示无信号
 */
uint8_t get_IRC_Value(void)
{
	return HAL_GPIO_ReadPin(HW3_GPIO_Port, HW3_Pin);
}

/*
 * 红外D通道获取值
 * @说明：由于采集时是低电平有效，所以返回值为0时表示有信号，返回值为1时表示无信号
 */
uint8_t get_IRD_Value(void)
{
	return HAL_GPIO_ReadPin(HW4_GPIO_Port, HW4_Pin);
}

/*
 * 红外E通道获取值
 * @说明：由于采集时是低电平有效，所以返回值为0时表示有信号，返回值为1时表示无信号
 */
uint8_t get_IRE_Value(void)
{
	return HAL_GPIO_ReadPin(HW5_GPIO_Port, HW5_Pin);
}



/*
 * 步进电机24BYJ48转过的圈数检测函数，使用的对射式红外传感器
 * @说明：检测到的圈数存储到全局变量 IRA_Count、IRB_Count、IRC_Count、IRD_Count、IRE_Count中，只要一个方向的自增
 * @参数：无
 * @返回值：无 
 * @作者：跳河轻生的鱼
 * @版本：V1.0.0
 * @时间：2024年12月13日
 * @版本修订说明：无
 */
void get_All_Value(void)
{
    static uint8_t get_IRA_flag = 0, get_IRB_flag = 0, get_IRC_flag = 0, get_IRD_flag = 0, get_IRE_flag = 0;
    /* 静态延时函数 */
    TickType_t xLastWakeTimeA, xLastWakeTimeB, xLastWakeTimeC, xLastWakeTimeD, xLastWakeTimeE;
    /* 固定100ms延时 */
    const TickType_t xDelay = pdMS_TO_TICKS(100); 
    /* 获取红外传感器A的值 */
    if(get_IRA_flag == 0 && get_IRA_Value () == 0)
    {
        get_IRA_flag = 1;
        /* 获取当前时间 */
        xLastWakeTimeA = xTaskGetTickCount();
        //获取互斥信号量
        if(xSemaphoreTake(xMutexA, portMAX_DELAY) == pdTRUE)
        {
            IRA_Count ++;       
            // 释放互斥信号量
            xSemaphoreGive(xMutexA);
        }
    }
    /* 100ms内不再进入get_IRB_Value函数 */
    if(get_IRA_flag == 1 && (xTaskGetTickCount() - xLastWakeTimeA > xDelay))
    {
        get_IRA_flag = 0;
    }
    /* 获取红外传感器B的值 */
    if(get_IRB_flag == 0 && get_IRB_Value () == 0)
    {
        get_IRB_flag = 1;
        /* 获取当前时间 */
        xLastWakeTimeB = xTaskGetTickCount();
        //获取互斥信号量
        if(xSemaphoreTake(xMutexB, portMAX_DELAY) == pdTRUE)
        {
            IRB_Count ++;
            // 释放互斥信号量
            xSemaphoreGive(xMutexB);
        }
    }
    /* 100ms内不再进入get_IRB_Value函数 */
    if(get_IRB_flag == 1 && (xTaskGetTickCount() - xLastWakeTimeB > xDelay))
    {
        get_IRB_flag = 0;
    }
    /* 获取红外传感器C的值 */
    if(get_IRC_flag == 0 && get_IRC_Value () == 0)
    {
        get_IRC_flag = 1;
        /* 获取当前时间 */
        xLastWakeTimeC = xTaskGetTickCount();
        //获取互斥信号量
        if(xSemaphoreTake(xMutexC, portMAX_DELAY) == pdTRUE)
        {
            IRC_Count ++;
            // 释放互斥信号量
            xSemaphoreGive(xMutexC);
        }
    }
    /* 100ms内不再进入get_IRB_Value函数 */
    if(get_IRC_flag == 1 && (xTaskGetTickCount() - xLastWakeTimeC > xDelay))
    {
        get_IRC_flag = 0;
    }
    /* 获取红外传感器D的值 */
    if(get_IRD_flag == 0 && get_IRD_Value () == 0)
    {
        get_IRD_flag = 1;
        /* 获取当前时间 */
        xLastWakeTimeD = xTaskGetTickCount();
        //获取互斥信号量
        if(xSemaphoreTake(xMutexD, portMAX_DELAY) == pdTRUE)
        {
            IRD_Count ++;
            // 释放互斥信号量
            xSemaphoreGive(xMutexD);
        }
    }
    /* 100ms内不再进入get_IRB_Value函数 */
    if(get_IRD_flag == 1 && (xTaskGetTickCount() - xLastWakeTimeD > xDelay))
    {
        get_IRD_flag = 0;
    }
    /* 获取红外传感器E的值 */
    if(get_IRE_flag == 0 && get_IRE_Value () == 0)
    {
        get_IRE_flag = 1;
        /* 获取当前时间 */
        xLastWakeTimeE = xTaskGetTickCount();
        //获取互斥信号量
        if(xSemaphoreTake(xMutexE, portMAX_DELAY) == pdTRUE)
        {
            IRE_Count ++;
            // 释放互斥信号量
            xSemaphoreGive(xMutexE);
        }
    }
    /* 100ms内不再进入get_IRB_Value函数 */
    if(get_IRE_flag == 1 && (xTaskGetTickCount() - xLastWakeTimeE > xDelay))
    {
        get_IRE_flag = 0;
    }    
}

/*
 * 步进电机24BYJ48转过的圈数进行数据清零
 * @说明：检测到的圈数存储到全局变量 IRA_Count、IRB_Count、IRC_Count、IRD_Count、IRE_Count中，调用函数将对应的变量清零
 * @参数：HW_X x 枚举变量，对应红外传感器的型号
 * @返回值：无 
 * @作者：跳河轻生的鱼
 * @版本：V1.0.0
 * @时间：2024年12月13日
 * @版本修订说明：无
 */
void HWReset_xCount(HW_X x)
{
    switch (x)
    {
    case HW_A:
        //获取互斥信号量
        if(xSemaphoreTake(xMutexA, portMAX_DELAY) == pdTRUE)
        {
            IRA_Count = 0;
            // 释放互斥信号量
            xSemaphoreGive(xMutexD);
        }
        break;
    case HW_B:
        //获取互斥信号量
        if(xSemaphoreTake(xMutexB, portMAX_DELAY) == pdTRUE)
        {
            IRB_Count = 0;
            // 释放互斥信号量
            xSemaphoreGive(xMutexB);
        }
        break;
    case HW_C:
        //获取互斥信号量
        if(xSemaphoreTake(xMutexC, portMAX_DELAY) == pdTRUE)
        {
            IRC_Count = 0;
            // 释放互斥信号量
            xSemaphoreGive(xMutexC);
        }
        break;
    case HW_D:
        //获取互斥信号量
        if(xSemaphoreTake(xMutexD, portMAX_DELAY) == pdTRUE)
        {
            IRD_Count = 0;
            // 释放互斥信号量
            xSemaphoreGive(xMutexD);
        }
        break;
    case HW_E:
        //获取互斥信号量
        if(xSemaphoreTake(xMutexE, portMAX_DELAY) == pdTRUE)
        {
            IRE_Count = 0;
            // 释放互斥信号量
            xSemaphoreGive(xMutexE);
        }
        break;
    default:
        break;
	}
}

/*
 * 步进电机24BYJ48转过的圈数进行数据清零
 * @说明：检测到的圈数存储到全局变量 IRA_Count、IRB_Count、IRC_Count、IRD_Count、IRE_Count中，调用函数将所有变量清零
 * @参数：无
 * @返回值：无
 * @作者：跳河轻生的鱼
 * @版本：V1.0.0
 * @时间：2024年12月13日
 * @版本修订说明：无
 */
void HwAllReset(void)
{
    HWReset_xCount(HW_A);
    HWReset_xCount(HW_B);
    HWReset_xCount(HW_C);
    HWReset_xCount(HW_D);
    HWReset_xCount(HW_E);
}
